home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1997 October: Mac OS SDK / Dev.CD Oct 97 SDK1.toast / Development Kits (Disc 1) / Installer SDK Cornucopia 1.0.2 / Script Examples / Simple Atom Extender / DirectCopyExtender.c next >
Encoding:
Text File  |  1996-09-26  |  17.7 KB  |  491 lines  |  [TEXT/MPS ]
  1. // DirectCopyExtender.c
  2. //
  3. //                This file contains code for the Simple Atom Extender example.  The
  4. //                Atom Extender defined below simulates the Installer's default copy
  5. //                task.
  6. //
  7. //
  8. //        Copyright 1993-1996, Apple Computer, Inc., All Rights Reserved
  9. //
  10. //
  11.  
  12. #ifndef __Errors__
  13. #include <Errors.h>
  14. #endif
  15.  
  16. #ifndef __Memory__
  17. #include <Memory.h>
  18. #endif
  19.  
  20. #ifndef __OSUtils__
  21. #include <OSUtils.h>
  22. #endif
  23.  
  24. #ifndef __Packages__
  25. #include <Packages.h>
  26. #endif
  27.  
  28. #include <TextUtils.h>
  29.  
  30. #ifndef __InstallerScript__
  31. #include "InstallerScript.h"
  32. #endif
  33.  
  34. #ifndef __ActionHandlerHeader__
  35. #include "ActionHandlerHeader.h"
  36. #endif
  37.  
  38. void DisplayAtomExtenderInfo( ExtenderPBPtr        pExtenderPBPtr, ExtenderResultCode pResultCode );
  39.  
  40. ExtenderResultCode DirectCopyExtender( ExtenderPBPtr        pExtenderPBPtr )
  41. {
  42.     OSErr                theErr;
  43.     long                dataLen;
  44.     Ptr                    theBufferPtr;
  45.     ExtenderResultCode    resultCode;
  46.  
  47.     // -- Initalize some important variables
  48.     dataLen = 30000;
  49.     theErr = noErr;
  50.  
  51.     // -- Depending on the message, perform the proper task
  52.     switch( pExtenderPBPtr->fFileCopyPBRec.fEnvironmentHeader.fMessageID ) {
  53.  
  54.         case kBeforePart:
  55.         
  56.             // -- Create a buffer
  57.             theBufferPtr = NewPtr(dataLen);
  58.         
  59.             // -- Check that we got our buffer successfully
  60.             if( theBufferPtr != NULL && MemError() == noErr ) {
  61.         
  62.                 // -- Read as much as we can up to the size of the buffer.
  63.                 theErr = ReadSourceData( pExtenderPBPtr->fBasicPBRec.fEnvironmentHeader.fCallBackProcPtr, &dataLen, theBufferPtr);
  64.  
  65.                 // -- Loop while there is more data to read. 
  66.                 while( dataLen > 0 ) {
  67.         
  68.         
  69.                     // -- DO SOMETHING TO THE DATA HERE, LIKE DECOMPRESSION IF YOU NEED TO
  70.         
  71.         
  72.                     // -- Write the data out.
  73.                     theErr = WriteTargetData( pExtenderPBPtr->fBasicPBRec.fEnvironmentHeader.fCallBackProcPtr, dataLen, theBufferPtr);
  74.                     
  75.                     // -- Read as much as we can up to the size of the buffer.
  76.                     if( theErr == noErr ) {
  77.                         theErr = ReadSourceData( pExtenderPBPtr->fBasicPBRec.fEnvironmentHeader.fCallBackProcPtr, &dataLen, theBufferPtr);
  78.                         
  79.                         // -- If we got an eofErr, then we know we're done, and dataLen will be 0 (zero).
  80.                         if( theErr == eofErr )
  81.                             theErr = noErr;
  82.                     }
  83.  
  84.                 } // while not done copying
  85.  
  86.                 if( theErr == noErr )
  87.                     resultCode = kCopiedData;
  88.                 else
  89.                     resultCode = kFatalError;
  90.  
  91.                 // -- Dispose the buffer
  92.                 DisposPtr(theBufferPtr);
  93.             }
  94.             else
  95.                 resultCode = kFatalError;
  96.  
  97.             // Write some handy info to the Installer Debugger, if it is installed.
  98.             DisplayAtomExtenderInfo( pExtenderPBPtr, resultCode );
  99.             break;
  100.     
  101.         // -- We ignore the other messages.
  102.         case kInitialize:
  103.         case kAfterPart:    
  104.         case kSuccess:    
  105.         case kCancel:
  106.             resultCode = kContinueAsNormal;
  107.             break;
  108.     }
  109.     
  110.     return resultCode;
  111. }
  112.  
  113.  
  114.  
  115.  
  116.  
  117.  
  118. // -------------------------------------------------------------------------------------------------------------------------------------
  119. // The routines below are for displaying the contents of the parameter block passed to the Atom Extender.
  120. // Call DisplayAtomExtenderInfo to write this information to the Installer Debugger.
  121.  
  122. void MakeFilePath( FSSpec* pFileFSSpec, Str255  pFilePath )
  123. {
  124.     
  125.     CInfoPBRec        cPBRec;
  126.     Str255            directoryName = "";
  127.     short            i;
  128.     OSErr            theErr;
  129.  
  130.     // Get the file name
  131.     for( i=0;i<=pFileFSSpec->name[0];i++)
  132.         pFilePath[i] = pFileFSSpec->name[i];
  133.  
  134.     cPBRec.hFileInfo.ioCompletion = NULL;
  135.     cPBRec.hFileInfo.ioNamePtr = directoryName;
  136.     cPBRec.hFileInfo.ioFDirIndex = -1;
  137.     cPBRec.hFileInfo.ioDirID = pFileFSSpec->parID;
  138.     cPBRec.hFileInfo.ioVRefNum = pFileFSSpec->vRefNum;
  139.     theErr = PBGetCatInfo( &cPBRec, 0 );
  140.  
  141.     // Preappend directoryName
  142.     BlockMove( pFilePath + 1, pFilePath + directoryName[0] + 2, pFilePath[0] );
  143.     for( i=1;i<=directoryName[0];i++)
  144.         pFilePath[i] = directoryName[i];
  145.     pFilePath[i] = ':';
  146.     pFilePath[0] += directoryName[0] + 1;
  147.  
  148.     while ( theErr == noErr && cPBRec.dirInfo.ioDrParID != 1 && pFilePath[0] + directoryName[0] + 1 < 255 ) {
  149.  
  150.     // Preappend directoryName
  151.         cPBRec.hFileInfo.ioDirID = cPBRec.dirInfo.ioDrParID;
  152.         cPBRec.hFileInfo.ioFDirIndex = -1;
  153.         theErr = PBGetCatInfo( &cPBRec, 0 );
  154.  
  155.         if( theErr == noErr ) {
  156.             // Preappend directoryName
  157.             BlockMove( pFilePath + 1, pFilePath + directoryName[0] + 2, pFilePath[0] );
  158.             for( i=1;i<=directoryName[0];i++)
  159.                 pFilePath[i] = directoryName[i];
  160.             pFilePath[i] = ':';
  161.             pFilePath[0] += directoryName[0] + 1;
  162.         }
  163.     }
  164.  
  165. }
  166.  
  167. void PrintLine( InstallerCallBackUPP pCallBackProcPtr, Str255 pParam0, Str255 pParam1, Str255 pParam2, Str255 pParam3 )
  168. {
  169.     long    theResult;
  170.     RegisterScriptAction( pCallBackProcPtr, kDebuggingAction, kGenericDebugActID, pParam0, pParam1, pParam2, pParam3, &theResult );    
  171. }
  172.  
  173. void DisplayAtomExtenderInfo( ExtenderPBPtr        pExtenderPBPtr, ExtenderResultCode pResultCode )
  174. {
  175.  
  176. StringPtr                    kBeginCallPart1                    = "\p=>========================== Begin Atom Extender Call ==== ";
  177. StringPtr                    kBeginCallPart3                    = "\p============================";
  178.  
  179. StringPtr                    kEndCallPart1                    = "\p-<-------------------------- End Atom Extender Call ------ ";
  180. StringPtr                    kEndCallPart3                    = "\p----------------------------\n";
  181.  
  182. StringPtr                    kRefConText                        = "\pRefCon: ";
  183.  
  184. StringPtr                    kTargetVolNumText                = "\p    TargetVolumeRefNum:  ";
  185. StringPtr                    kTargetBlessedDirIDText            = "\p    TargetBlessedDirID:  ";
  186. StringPtr                    kBootVolNumText                    = "\p      BootVolumeRefNum:  ";
  187. StringPtr                    kBootBlessedDirIDText            = "\p      BootBlessedDirID:  ";
  188.  
  189. StringPtr                    kInitializeText                    = "\pInitialization Call =";
  190. StringPtr                    kSuccessText                    = "\pSuccessful Completion";
  191. StringPtr                    kBeforePartText                    = "\pBefore Part =========";
  192. StringPtr                    kAfterPartText                    = "\pAfter Part ==========";
  193. StringPtr                    kCancelText                        = "\pCANCELIZATION CALL ==";
  194.  
  195. StringPtr                    kOkRtnMessageText                ="\pContinue result returned --";
  196. StringPtr                    kCancelRtnMessageText            ="\pCancel result returned ----";
  197. StringPtr                    kErrorRtnMessageText            ="\pError result returned -----";
  198. StringPtr                    kCopiedDataMessageText            ="\pCopied Data result returned";
  199.  
  200. StringPtr                    kFileAtomDataForkText            = "\pDataType:  FileAtomDataFork";
  201. StringPtr                    kFileAtomRsrcForkText            = "\pDataType:  FileAtomRsrcFork";
  202. StringPtr                    kFileAtomRsrcForkFromDataForkText= "\pDataType:  FileAtomRsrcForkFromDataFork";
  203. StringPtr                    kRsrcAtomText                    = "\pDataType:  RsrcAtom";
  204. StringPtr                    kFontAtomText                    = "\pDataType:  FontAtom";
  205. StringPtr                    kActionAtomText                    = "\pDataType:  N/A";
  206.  
  207. StringPtr                    kSourceFileText                    = "\pSource Info...  ";
  208. StringPtr                    kTargetFileText                    = "\pTarget Info...  ";
  209. StringPtr                    kFSSpecNameText                    = "\p      File Path:  ";
  210. StringPtr                    kPartSizeText                    = "\p      Part Size:  ";
  211. StringPtr                    kPosSizeText                    = "\p      Start Pos:  ";
  212. StringPtr                    kTotalSizeText                    = "\p     Total Size:  ";
  213.  
  214. StringPtr                    kRsrcSourceRsrcTypeText            = "\p  Src Rsrc Type:  ";
  215. StringPtr                    kRsrcSourceRsrcIDText            = "\p    Src Rsrc ID:  ";
  216. StringPtr                    kRsrcTargetRsrcTypeText            = "\p  Tgt Rsrc Type:  ";
  217. StringPtr                    kRsrcTargetRsrcIDText            = "\p    Tgt Rsrc ID:  ";
  218. StringPtr                    kRsrcTargetRsrcNameText            = "\p      Rsrc Name:  ";
  219. StringPtr                    kRsrcTargetRsrcAttrsText        = "\p     Rsrc Attrs:  ";
  220.  
  221. StringPtr                    kFontSourceRsrcTypeText            = "\p  Src Rsrc Type:  ";
  222. StringPtr                    kFontSourceRsrcIDText            = "\p    Src Rsrc ID:  ";
  223. StringPtr                    kFontTargetRsrcTypeText            = "\p  Tgt Rsrc Type:  ";
  224. StringPtr                    kFontTargetRsrcIDText            = "\p    Tgt Rsrc ID:  ";
  225. StringPtr                    kFontTargetRsrcNameText            = "\p      Rsrc Name:  ";
  226. StringPtr                    kFontTargetRsrcAttrsText        = "\p     Rsrc Attrs:  ";
  227. StringPtr                    kFontFamilyNameText                = "\p    Family Name:  ";
  228. StringPtr                    kFontFamilyIDText                = "\p      Family ID:  ";
  229. StringPtr                    kFontFontSizeText                = "\p      Font Size:  ";
  230. StringPtr                    kFontFontStyleText                = "\p     Font Style:  ";
  231.  
  232. StringPtr                    kInstallerTempDirIDText            = "\p Temp Directory:  ";
  233.  
  234. Str255                        tempNumStr;    
  235. Str255                        tempStr255;
  236. FSSpec                        tempFSSpec;
  237. InstallerCallBackUPP        theCallBackPtr = pExtenderPBPtr->fBasicPBRec.fEnvironmentHeader.fCallBackProcPtr;
  238.  
  239.  
  240. // -- BASIC STUFF ----------------------------------------------------------------------
  241.  
  242.     switch (pExtenderPBPtr->fBasicPBRec.fEnvironmentHeader.fMessageID) {
  243.         case kInitialize :        PrintLine( theCallBackPtr, kBeginCallPart1, kInitializeText, kBeginCallPart3, "\p" );
  244.                                 break;
  245.         case kSuccess :            PrintLine( theCallBackPtr, kBeginCallPart1, kSuccessText, kBeginCallPart3, "\p" );
  246.                                 break;
  247.         case kBeforePart :        PrintLine( theCallBackPtr, kBeginCallPart1, kBeforePartText, kBeginCallPart3, "\p" );
  248.                                 break;
  249.         case kAfterPart :        PrintLine( theCallBackPtr, kBeginCallPart1, kAfterPartText, kBeginCallPart3, "\p" );
  250.                                 break;
  251.         case kCancel :            PrintLine( theCallBackPtr, kBeginCallPart1, kCancelText, kBeginCallPart3, "\p" );
  252.                                 break;
  253.         }
  254.     
  255.     switch (pExtenderPBPtr->fBasicPBRec.fEnvironmentHeader.fMessageID) {
  256.         case kInitialize :
  257.         case kSuccess :
  258.         case kCancel :
  259.             NumToString( pExtenderPBPtr->fBasicPBRec.fEnvironmentHeader.fRefCon, (StringPtr)&tempNumStr );
  260.             PrintLine( theCallBackPtr, kRefConText, tempNumStr, "\p", "\p" );
  261.             break;
  262.             
  263.         case kBeforePart :
  264.         case kAfterPart :
  265.             
  266.             NumToString( pExtenderPBPtr->fBasicPBRec.fEnvironmentHeader.fRefCon, (StringPtr)&tempNumStr );
  267.             PrintLine( theCallBackPtr, kRefConText, tempNumStr, "\p", "\p" );
  268.                                 
  269.             switch (pExtenderPBPtr->fBasicPBRec.fEnvironmentHeader.fDataType) {
  270.                 case kFileAtomDataFork :                PrintLine( theCallBackPtr, kFileAtomDataForkText, "\p", "\p", "\p" );
  271.                                                         break;
  272.                 case kFileAtomRsrcFork :                PrintLine( theCallBackPtr, kFileAtomRsrcForkText, "\p", "\p", "\p" );
  273.                                                         break;
  274.                 case kFileAtomRsrcForkFromDataFork :    PrintLine( theCallBackPtr, kFileAtomRsrcForkFromDataForkText, "\p", "\p", "\p" );
  275.                                                         break;
  276.                 case kRsrcAtom :                        PrintLine( theCallBackPtr, kRsrcAtomText, "\p", "\p", "\p" );
  277.                                                         break;
  278.                 case kFontAtom :                        
  279.                                                         // -- Font Atom Description
  280.                                                         PrintLine( theCallBackPtr, kFontAtomText, "\p", "\p", "\p" );
  281.                                                     
  282.                                                         // -- Font Family Name
  283.                                                         PrintLine( theCallBackPtr, kFontFamilyNameText, pExtenderPBPtr->fFontCopyPBRec.fFamilyName, "\p", "\p" );
  284.                                     
  285.                                                         // -- Font Family ID
  286.                                                         NumToString( pExtenderPBPtr->fFontCopyPBRec.fFamilyID, (StringPtr)&tempNumStr );
  287.                                                         PrintLine( theCallBackPtr, kFontFamilyIDText, tempNumStr, "\p", "\p" );
  288.                                                         
  289.                                                         // -- Font Strike Size
  290.                                                         NumToString( pExtenderPBPtr->fFontCopyPBRec.fFontSize, (StringPtr)&tempNumStr );
  291.                                                         PrintLine( theCallBackPtr, kFontFontSizeText, tempNumStr, "\p", "\p" );
  292.                                                         
  293.                                                         // -- Font Strike Style
  294.                                                         NumToString( pExtenderPBPtr->fFontCopyPBRec.fFontStyle, (StringPtr)&tempNumStr );
  295.                                                         PrintLine( theCallBackPtr, kFontFontStyleText, tempNumStr, "\p", "\p" );
  296.                                                         break;
  297.                     
  298.                 case kActionAtom :                        PrintLine( theCallBackPtr, kActionAtomText, "\p", "\p", "\p" );
  299.                                                         break;
  300.                 }
  301.                                 break;
  302.         }
  303.  
  304.  
  305. // -- BASIC SOURCE INFO ----------------------------------------------------------------------
  306.  
  307.     switch (pExtenderPBPtr->fBasicPBRec.fEnvironmentHeader.fMessageID) {
  308.          case kBeforePart :
  309.         case kAfterPart :
  310.         // -- SOURCE FILE ----------------------------------------------------------------------
  311.             // -- Source Title
  312.             PrintLine( theCallBackPtr, kSourceFileText, "\p", "\p", "\p" );
  313.         
  314.             MakeFilePath( &(pExtenderPBPtr->fBasicPBRec.fCopyPBHeader.fSourceFile), tempStr255 );
  315.             PrintLine( theCallBackPtr, kFSSpecNameText, tempStr255, "\p", "\p" );
  316.         
  317.             NumToString( pExtenderPBPtr->fBasicPBRec.fCopyPBHeader.fSourcePartSize, (StringPtr)&tempNumStr );
  318.             PrintLine( theCallBackPtr, kPartSizeText, tempNumStr, "\p", "\p" );
  319.             break;
  320.         }
  321.     
  322. // -- ATOM SOURCE SPECIFIC INFO ----------------------------------------------------------------------
  323.  
  324.     switch (pExtenderPBPtr->fBasicPBRec.fEnvironmentHeader.fMessageID) {
  325.         case kInitialize :
  326.         case kSuccess :
  327.             break;
  328.         case kBeforePart :
  329.         case kAfterPart :
  330.             switch (pExtenderPBPtr->fBasicPBRec.fEnvironmentHeader.fDataType) {
  331.                 case kFileAtomDataFork :
  332.                 case kFileAtomRsrcFork :
  333.                 case kFileAtomRsrcForkFromDataFork :
  334.                     break;
  335.                 case kRsrcAtom :
  336.                     // -- Resource Source Type
  337.                     BlockMove( &(pExtenderPBPtr->fRsrcCopyPBRec.fSourceRsrcType), &(tempStr255[2]), 4 );
  338.                     tempStr255[1] = '\'';
  339.                     tempStr255[6] = '\'';
  340.                     tempStr255[0] = 6;
  341.                     PrintLine( theCallBackPtr, kRsrcSourceRsrcTypeText, tempStr255, "\p", "\p" );
  342.                     
  343.                     // -- Resource Source ID
  344.                     NumToString( pExtenderPBPtr->fRsrcCopyPBRec.fSourceRsrcID, (StringPtr)&tempNumStr );
  345.                     PrintLine( theCallBackPtr, kRsrcSourceRsrcIDText, tempNumStr, "\p", "\p" );
  346.  
  347.                     break;
  348.                 case kFontAtom :
  349.                     // -- Font Source Type
  350.                     BlockMove( &(pExtenderPBPtr->fFontCopyPBRec.fSourceFontRsrcType), &(tempStr255[2]), 4 );
  351.                     tempStr255[1] = '\'';
  352.                     tempStr255[6] = '\'';
  353.                     tempStr255[0] = 6;
  354.                     PrintLine( theCallBackPtr, kFontSourceRsrcTypeText, tempStr255, "\p", "\p" );
  355.                 
  356.                     // -- Font Source ID
  357.                     NumToString( pExtenderPBPtr->fFontCopyPBRec.fSourceFontRsrcID, (StringPtr)&tempNumStr );
  358.                     PrintLine( theCallBackPtr, kFontSourceRsrcIDText, tempNumStr, "\p", "\p" );
  359.  
  360.                     break;
  361.                 default :
  362.                     break;
  363.                 }
  364.             break;
  365.         case kCancel :
  366.                 break;
  367.         }
  368.  
  369.  
  370. // -- BASIC TARGET INFO ----------------------------------------------------------------------
  371.  
  372.     switch (pExtenderPBPtr->fBasicPBRec.fEnvironmentHeader.fMessageID) {
  373.          case kBeforePart :
  374.         case kAfterPart :
  375.         
  376.         // -- TARGET FILE ----------------------------------------------------------------------
  377.             // -- Target Title
  378.             PrintLine( theCallBackPtr, kTargetFileText, "\p", "\p", "\p" );
  379.         
  380.             // -- Target File Name
  381.             MakeFilePath( &(pExtenderPBPtr->fBasicPBRec.fCopyPBHeader.fTargetFile), tempStr255 );
  382.             PrintLine( theCallBackPtr, kFSSpecNameText, tempStr255, "\p", "\p" );
  383.         
  384.             // -- Target Start Position
  385.             NumToString( pExtenderPBPtr->fBasicPBRec.fCopyPBHeader.fTargetPosStart, (StringPtr)&tempNumStr );
  386.             PrintLine( theCallBackPtr, kPosSizeText, tempNumStr, "\p", "\p" );
  387.         
  388.             // -- Target Part Size
  389.             NumToString( pExtenderPBPtr->fBasicPBRec.fCopyPBHeader.fTargetPartSize, (StringPtr)&tempNumStr );
  390.             PrintLine( theCallBackPtr, kPartSizeText, tempNumStr, "\p", "\p" );
  391.         
  392.             // -- Target Total Size
  393.             NumToString( pExtenderPBPtr->fBasicPBRec.fCopyPBHeader.fTotalTargetSize, (StringPtr)&tempNumStr );
  394.             PrintLine( theCallBackPtr, kTotalSizeText, tempNumStr, "\p", "\p" );
  395.                             
  396.             // -- Installer Temp Dir ID
  397.             if( pExtenderPBPtr->fBasicPBRec.fCopyPBHeader.fInstallerTempDirID != -1 ) {
  398.                 tempFSSpec.name[0] = 0;
  399.                 tempFSSpec.parID = pExtenderPBPtr->fBasicPBRec.fCopyPBHeader.fInstallerTempDirID;
  400.                 tempFSSpec.vRefNum = pExtenderPBPtr->fBasicPBRec.fCopyPBHeader.fTargetFile.vRefNum;
  401.                 MakeFilePath( &(tempFSSpec), tempStr255 );
  402.                 PrintLine( theCallBackPtr, kInstallerTempDirIDText, tempStr255, "\p", "\p" );
  403.             }
  404.  
  405.             break;
  406.             
  407.         }
  408.  
  409. // -- ATOM TARGET SPECIFIC INFO ----------------------------------------------------------------------
  410.  
  411.     switch (pExtenderPBPtr->fBasicPBRec.fEnvironmentHeader.fMessageID) {
  412.         case kInitialize :
  413.         case kSuccess :
  414.             break;
  415.         case kBeforePart :
  416.         case kAfterPart :
  417.             switch (pExtenderPBPtr->fBasicPBRec.fEnvironmentHeader.fDataType) {
  418.                 case kFileAtomDataFork :
  419.                 case kFileAtomRsrcFork :
  420.                 case kFileAtomRsrcForkFromDataFork :
  421.                     break;
  422.                 case kRsrcAtom :
  423.                     // -- Resource Target Type
  424.                     BlockMove( &(pExtenderPBPtr->fRsrcCopyPBRec.fTargetRsrcType), &(tempStr255[2]), 4 );
  425.                     tempStr255[1] = '\'';
  426.                     tempStr255[6] = '\'';
  427.                     tempStr255[0] = 6;
  428.                     PrintLine( theCallBackPtr, kRsrcTargetRsrcTypeText, tempStr255, "\p", "\p" );
  429.                     
  430.                     // -- Resource Target ID
  431.                     NumToString( pExtenderPBPtr->fRsrcCopyPBRec.fTargetRsrcID, (StringPtr)&tempNumStr );
  432.                     PrintLine( theCallBackPtr, kRsrcTargetRsrcIDText, tempNumStr, "\p", "\p" );
  433.  
  434.                     // -- Resource Target Name
  435.                     PrintLine( theCallBackPtr, kRsrcTargetRsrcNameText, pExtenderPBPtr->fRsrcCopyPBRec.fTargetRsrcName, "\p", "\p" );
  436.  
  437.                     // -- Resource Target Attributes
  438.                     NumToString( pExtenderPBPtr->fRsrcCopyPBRec.fTargetRsrcAttrs, (StringPtr)&tempNumStr );
  439.                     PrintLine( theCallBackPtr, kRsrcTargetRsrcAttrsText, tempNumStr, "\p", "\p" );
  440.  
  441.                     break;
  442.                 case kFontAtom :
  443.                     // -- Font Target Type
  444.                     BlockMove( &(pExtenderPBPtr->fFontCopyPBRec.fTargetFontRsrcType), &(tempStr255[2]), 4 );
  445.                     tempStr255[1] = '\'';
  446.                     tempStr255[6] = '\'';
  447.                     tempStr255[0] = 6;
  448.                     PrintLine( theCallBackPtr, kFontTargetRsrcTypeText, tempStr255, "\p", "\p" );
  449.                     
  450.                     // -- Font Target ID
  451.                     if( pExtenderPBPtr->fBasicPBRec.fEnvironmentHeader.fMessageID == kAfterPart ) {
  452.                         NumToString( pExtenderPBPtr->fFontCopyPBRec.fTargetFontRsrcID, (StringPtr)&tempNumStr );
  453.                         PrintLine( theCallBackPtr, kFontTargetRsrcIDText, tempNumStr, "\p", "\p" );
  454.                     }
  455.                     
  456.                     // -- Font Target Name
  457.                     PrintLine( theCallBackPtr, kFontTargetRsrcNameText, pExtenderPBPtr->fFontCopyPBRec.fTargetFontRsrcName, "\p", "\p" );
  458.  
  459.                     // -- Font Target Attributes
  460.                     NumToString( pExtenderPBPtr->fFontCopyPBRec.fTargetFontRsrcAttrs, (StringPtr)&tempNumStr );
  461.                     PrintLine( theCallBackPtr, kFontTargetRsrcAttrsText, tempNumStr, "\p", "\p" );
  462.                     
  463.                     break;
  464.                 default :
  465.                     break;
  466.                 }
  467.             break;
  468.         case kCancel :
  469.                 break;
  470.         }
  471.         
  472.         
  473.         
  474. // -- RESULT INFO ----------------------------------------------------------------------
  475.     switch (pResultCode) {
  476.         case kFatalError :            PrintLine( theCallBackPtr, kEndCallPart1, kErrorRtnMessageText, kEndCallPart3, "\p" );
  477.                                     break;
  478.         case kContinueAsNormal :    PrintLine( theCallBackPtr, kEndCallPart1, kOkRtnMessageText, kEndCallPart3, "\p" );
  479.                                     break;
  480.         case kCancelInstallation :    PrintLine( theCallBackPtr, kEndCallPart1, kCancelRtnMessageText, kEndCallPart3, "\p" );
  481.                                     break;
  482.         case kCopiedData :            PrintLine( theCallBackPtr, kEndCallPart1, kCopiedDataMessageText, kEndCallPart3, "\p" );
  483.                                     break;
  484.         }
  485.  
  486.  
  487. }
  488.  
  489.  
  490. #include  "InstallerCallbackGlue.c"
  491.